// @file s/client_info.h

/*
 *    Copyright (C) 2010 10gen Inc.
 *
 *    This program is free software: you can redistribute it and/or  modify
 *    it under the terms of the GNU Affero General Public License, version 3,
 *    as published by the Free Software Foundation.
 *
 *    This program is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU Affero General Public License for more details.
 *
 *    You should have received a copy of the GNU Affero General Public License
 *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 *    As a special exception, the copyright holders give permission to link the
 *    code of portions of this program with the OpenSSL library under certain
 *    conditions as described in each individual source file and distribute
 *    linked combinations including the program with the OpenSSL library. You
 *    must comply with the GNU Affero General Public License in all respects
 *    for all of the code used other than as permitted herein. If you modify
 *    file(s) with this exception, you may extend this exception to your
 *    version of the file(s), but you are not obligated to do so. If you do not
 *    wish to do so, delete this exception statement from your version. If you
 *    delete this exception statement from all source files in the program,
 *    then also delete it in the license file.
 */
#pragma once

#include "mongo/pch.h"

#include <map>
#include <set>
#include <vector>

#include "mongo/db/client_basic.h"
#include "mongo/s/chunk.h"
#include "mongo/s/write_ops/batch_write_exec.h"
#include "mongo/util/net/hostandport.h"

namespace mongo {

    class AbstractMessagingPort;

    /**
     * holds information about a client connected to a mongos
     * 1 per client socket
     * currently implemented with a thread local
     */
    class ClientInfo : public ClientBasic {
    public:
        ClientInfo(AbstractMessagingPort* messagingPort);
        ~ClientInfo();

        /** new request on behalf of a client, adjusts internal state */
        void newPeerRequest( const HostAndPort& peer );

        /** new request not associated (yet or ever) with a client */
        void newRequest();


        /** client disconnected */
        void disconnect();

        bool hasRemote() const { return true; }

        /**
         * @return remote socket address of the client
         */
        HostAndPort getRemote() const { return _remote; }

        /**
         * notes that this client use this shard
         * keeps track of all shards accessed this request
         */
        void addShardHost( const std::string& shardHost );

        /**
         * Notes that this client wrote to these particular hosts with write commands.
         */
        void addHostOpTime(ConnectionString connstr, HostOpTime stat);
        void addHostOpTimes( const HostOpTimeMap& hostOpTimes );

        /**
         * gets shards used on the previous request
         */
        std::set<std::string>* getPrevShardHosts() const { return &_prev->shardHostsWritten; }

        /**
         * Gets the shards, hosts, and opTimes the client last wrote to with write commands.
         */
        const HostOpTimeMap& getPrevHostOpTimes() const {
            return _prev->hostOpTimes;
        }

        /**
         * gets all shards we've accessed since the last time we called clearSinceLastGetError
         */
        const std::set<std::string>& sinceLastGetError() const { return _sinceLastGetError; }

        /**
         * clears list of shards we've talked to
         */
        void clearSinceLastGetError() { _sinceLastGetError.clear(); }


        /**
         * resets the information stored for the current request
         */
        void clearRequestInfo(){ _cur->clear(); }

        void disableForCommand();

        /** @return if its ok to auto split from this client */
        bool autoSplitOk() const { return _autoSplitOk && Chunk::ShouldAutoSplit; }

        void noAutoSplit() { _autoSplitOk = false; }

        // Returns whether or not a ClientInfo for this thread has already been created and stored
        // in _tlInfo.
        static bool exists();
        // Gets the ClientInfo object for this thread from _tlInfo. If no ClientInfo object exists
        // yet for this thread, it creates one.
        static ClientInfo * get(AbstractMessagingPort* messagingPort = NULL);
        // Creates a ClientInfo and stores it in _tlInfo
        static ClientInfo* create(AbstractMessagingPort* messagingPort);

    private:

        int _id; // unique client id
        HostAndPort _remote; // server:port of remote socket end

        struct RequestInfo {

            void clear() {
                shardHostsWritten.clear();
                hostOpTimes.clear();
            }

            std::set<std::string> shardHostsWritten;
            HostOpTimeMap hostOpTimes;
        };

        // we use _a and _b to store info from the current request and the previous request
        // we use 2 so we can flip for getLastError type operations

        RequestInfo _a; // actual set for _cur or _prev
        RequestInfo _b; //   "

        RequestInfo* _cur; // pointer to _a or _b depending on state
        RequestInfo* _prev; //  ""


        std::set<std::string> _sinceLastGetError; // all shards accessed since last getLastError

        int _lastAccess;
        bool _autoSplitOk;

        static boost::thread_specific_ptr<ClientInfo> _tlInfo;
    };

    /* Look for $gleStats in a command response, and fill in ClientInfo with the data,
     * if found.
     * This data will be used by subsequent GLE calls, to ensure we look for the correct
     * write on the correct PRIMARY.
     * result: the result from calling runCommand
     * conn: the std::string name of the hostAndPort where the command ran. This can be a replica set
     *       seed list.
     */
    void saveGLEStats(const BSONObj& result, const std::string& conn);
}
